性能设计篇之"缓存" [2026重制版]

@Service
@RequiredArgsConstructor
@Slf4j
public class ProductService {

    private final ProductMapper productMapper;
    private final StringRedisTemplate redisTemplate;

    private static final String CACHE_KEY_PREFIX = "product:";
    private static final Duration CACHE_TTL = Duration.ofHours(1);

    /**
     * Cache Aside 读操作
     */
    public Product getProductById(String productId) {
        String cacheKey = CACHE_KEY_PREFIX + productId;

        // 1. 先查缓存
        String cached = redisTemplate.opsForValue().get(cacheKey);
        if (StringUtils.hasText(cached)) {
            log.debug("缓存命中: {}", cacheKey);
            return JSON.parseObject(cached, Product.class);
        }

        // 2. 缓存未命中，查数据库
        log.info("缓存未命中，查询数据库: {}", productId);
        Product product = productMapper.selectById(productId);

        if (product != null) {
            // 3. 写入缓存
            try {
                redisTemplate.opsForValue().set(
                    cacheKey,
                    JSON.toJSONString(product),
                    CACHE_TTL
                );
                log.debug("已写入缓存: {}", cacheKey);
            } catch (Exception e) {
                log.warn("写入缓存失败，不影响主流程", e);
            }
        }

        return product;
    }

    /**
     * Cache Aside 写操作 — 先更库，再删缓存
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean updateProduct(Product product) {
        // 1. 先更新数据库
        int rows = productMapper.updateById(product);

        if (rows > 0) {
            // 2. 删除缓存（不是更新！）
            String cacheKey = CACHE_KEY_PREFIX + product.getId();
            try {
                Boolean deleted = redisTemplate.delete(cacheKey);
                log.info("删除缓存: {}, 结果: {}", cacheKey, deleted);
            } catch (Exception e) {
                log.warn("删除缓存失败", e);
                // 可以放入消息队列异步补偿删除
                sendCacheInvalidationMessage(cacheKey);
            }
        }

        return rows > 0;
    }
}

# redis-production.conf — Redis 7.2 生产配置

# ====== 基础配置 ======
bind 0.0.0.0
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize yes
supervised systemd
pidfile /var/run/redis_6379.pid
loglevel notice
logfile /var/log/redis/redis-server.log
databases 16

# ====== 内存管理 ======
maxmemory 8gb
maxmemory-policy allkeys-lru
maxmemory-samples 5

# ====== 持久化配置 (RDB + AOF 双保险) ======
save 900 1
save 300 10
save 60 10000
dbfilename dump.rdb
dir /var/lib/redis/

appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes

# ====== 复制配置 ======
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync yes
repl-diskless-sync-delay 5
repl-ping-replica-period 10
repl-timeout 60
repl-disable-tcp-nodelay no
replica-priority 100

# ====== 安全配置 ======
acllog-max-length 128
requirepass ${REDIS_PASSWORD}

# ====== 客户端限制 ======
maxclients 10000

# ====== 慢查询日志 ======
slowlog-log-slower-than 10000
slowlog-max-len 128

# ====== 高级配置 ======
latency-monitor-threshold 100
notify-keyspace-events Ex
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

# ====== Redis Functions (7.0+) ======
function-max-buckets 1024
function-max-libraries 128

# docker-compose-redis.yml
version: '3.8'

services:
  # Master 节点
  redis-master:
    image: redis:7.2-alpine
    container_name: redis-master
    command: >
      redis-server
      --port 6379
      --requirepass ${REDIS_PASSWORD}
      --masterauth ${REDIS_PASSWORD}
      --maxmemory 2gb
      --maxmemory-policy allkeys-lru
      --appendonly yes
      --appendfsync everysec
      --save 900 1
      --save 300 10
      --save 60 10000
    ports:
      - "6379:6379"
    volumes:
      - redis-master-data:/data
    networks:
      - redis-net
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Slave-1 节点
  redis-slave-1:
    image: redis:7.2-alpine
    container_name: redis-slave-1
    command: >
      redis-server
      --port 6380
      --requirepass ${REDIS_PASSWORD}
      --masterauth ${REDIS_PASSWORD}
      --slaveof redis-master 6379
      --maxmemory 2gb
      --maxmemory-policy allkeys-lru
      --appendonly yes
    ports:
      - "6380:6380"
    volumes:
      - redis-slave-1-data:/data
    depends_on:
      redis-master:
        condition: service_healthy
    networks:
      - redis-net

  # Slave-2 节点
  redis-slave-2:
    image: redis:7.2-alpine
    container_name: redis-slave-2
    command: >
      redis-server
      --port 6381
      --requirepass ${REDIS_PASSWORD}
      --masterauth ${REDIS_PASSWORD}
      --slaveof redis-master 6379
      --maxmemory 2gb
      --maxmemory-policy allkeys-lru
      --appendonly yes
    ports:
      - "6381:6381"
    volumes:
      - redis-slave-2-data:/data
    depends_on:
      redis-master:
        condition: service_healthy
    networks:
      - redis-net

  # Sentinel-1
  sentinel-1:
    image: redis:7.2-alpine
    container_name: sentinel-1
    command: >
      redis-sentinel
      /usr/local/etc/redis/sentinel.conf
      --sentinel
      --port 26379
      --sentinel monitor mymaster redis-master 6379 2
      --sentinel down-after-milliseconds mymaster 5000
      --sentinel failover-timeout mymaster 60000
      --sentinel parallel-syncs mymaster 1
    volumes:
      - ./sentinel.conf:/usr/local/etc/redis/sentinel.conf
    ports:
      - "26379:26379"
    depends_on:
      redis-master:
        condition: service_healthy
    networks:
      - redis-net

volumes:
  redis-master-data:
  redis-slave-1-data:
  redis-slave-2-data:

networks:
  redis-net:
    driver: bridge

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

@Configuration
@EnableCaching
public class CacheConfig {

    /**
     * L1 本地缓存 - Caffeine 配置
     */
    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();

        // 全局默认配置
        cacheManager.setCaffeine(Caffeine.newBuilder()
            // 最大缓存条目数
            .maximumSize(10_000)
            // 基于权重的淘汰（可选）
            // .maximumWeight(100_000)
            // .weigher((key, value) -> estimateWeight(value))
            // 写入后过期时间
            .expireAfterWrite(5, TimeUnit.MINUTES)
            // 访问后刷新（Refresh After Access）
            .refreshAfterWrite(1, TimeUnit.MINUTES)
            // 初始化容量
            .initialCapacity(1000)
            // 并发级别
            .concurrencyLevel(Runtime.getRuntime().availableProcessors())
            // 统计信息收集（用于监控）
            .recordStats()
        );

        return cacheManager;
    }

    /**
     * 特定缓存的自定义配置
     */
    @Bean
    public Cache<String, Object> hotDataCache() {
        return Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.SECONDS)
            .refreshAfterWrite(5, TimeUnit.SECONDS)
            .recordStats()
            .build();
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class DictionaryService {

    private final DictMapper dictMapper;
    private final Cache<String, List<DictItem>> localCache;

    /**
     * 使用 @Cacheable 注解（Spring Cache 抽象）
     */
    @Cacheable(value = "dictionary", key = "#dictType", unless = "#result == null || #result.isEmpty()")
    public List<DictItem> getDictByType(String dictType) {
        log.info("查询字典类型: {} （未命中本地缓存）", dictType);
        return dictMapper.selectByType(dictType);
    }

    /**
     * 手动使用 Caffeine API（更灵活）
     */
    public DictItem getDictItem(String dictType, String itemCode) {
        String key = dictType + ":" + itemCode;

        // getIfPresent — 仅查缓存
        DictItem cached = localCache.getIfPresent(key);
        if (cached != null) {
            return cached;
        }

        // get — 支持缓存加载（CacheLoader）
        return localCache.get(key, k -> {
            log.info("加载数据字典: {}", k);
            return dictMapper.selectByTypeAndCode(dictType, itemCode);
        });
    }

    /**
     * 更新时清除缓存
     */
    @CacheEvict(value = "dictionary", key = "#dictType")
    public void updateDict(String dictType, List<DictItem> items) {
        dictMapper.batchUpdate(dictType, items);
        log.info("已清除字典缓存: type={}", dictType);
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class MultiLevelCacheService {

    private final CaffeineCache l1Cache;       // L1: Caffeine 本地缓存
    private final StringRedisTemplate l2Cache;   // L2: Redis 分布式缓存
    private final ProductMapper productMapper;   // L3: MySQL

    /** L1 缓存 TTL: 5 分钟 */
    private static final Duration L1_TTL = Duration.ofMinutes(5);
    /** L2 缓存 TTL: 1 小时 */
    private static final Duration L2_TTL = Duration.ofHours(1);

    /**
     * 多级缓存查询
     */
    public Product getProductMultiLevel(String productId) {
        String cacheKey = "product:" + productId;

        // ====== Level 1: 本地缓存 ======
        Product product = l1Cache.get(cacheKey);
        if (product != null) {
            metricsCounter.increment("cache.l1.hit");
            return product;  // L1 命中，直接返回 (~0.05ms)
        }
        metricsCounter.increment("cache.l1.miss");

        // ====== Level 2: Redis 缓存 ======
        String json = l2Cache.opsForValue().get(cacheKey);
        if (StringUtils.hasText(json)) {
            product = JSON.parseObject(json, Product.class);
            // 回填 L1
            l1Cache.put(cacheKey, product, L1_TTL);
            metricsCounter.increment("cache.l2.hit");
            return product;  // L2 命中 (~1ms)
        }
        metricsCounter.increment("cache.l2.miss");

        // ====== Level 3: 数据库 ======
        product = productMapper.selectById(productId);
        if (product != null) {
            String productJson = JSON.toJSONString(product);

            // 并行回填 L1 和 L2（降低总耗时）
            CompletableFuture.allOf(
                CompletableFuture.runAsync(() ->
                    l1Cache.put(cacheKey, product, L1_TTL)),
                CompletableFuture.runAsync(() ->
                    l2Cache.opsForValue().set(cacheKey, productJson, L2_TTL))
            ).orTimeout(500, TimeUnit.MILLISECONDS)
             .exceptionally(ex -> {
                 log.warn("缓存回填失败（非致命）", ex);
                 return null;
             });

            metricsCounter.increment("cache.db.query");
        }

        return product;
    }

    /**
     * 多级缓存失效 — 广播通知所有节点清除 L1
     */
    public void invalidateProduct(String productId) {
        String cacheKey = "product:" + productId;

        // 1. 删除 L2 (Redis)
        l2Cache.delete(cacheKey);

        // 2. 发布缓存失效事件（通过 Redis Pub/Sub）
        l2Cache.convertAndSend(
            "cache:invalidation",
            new CacheInvalidationEvent("product", productId)
        );

        // 3. 清除当前节点的 L1
        l1Cache.invalidate(cacheKey);

        log.info("多级缓存已失效: {}", cacheKey);
    }

    /**
     * 监听缓存失效事件（清除本地 L1）
     */
    @EventListener
    public void onCacheInvalidation(CacheInvalidationEvent event) {
        String cacheKey = event.getType() + ":" + event.getKey();
        l1Cache.invalidate(cacheKey);
        log.debug("收到缓存失效通知，已清除L1: {}", cacheKey);
    }
}

/**
 * 方案一：布隆过滤器防止穿透
 */
@Component
public class BloomFilterCache {

    private final BloomFilter<String> bloomFilter;

    public BloomFilterCache() {
        // 预计元素数量 100万，误判率 1%
        this.bloomFilter = BloomFilter.create(
            Funnels.stringFunnel(Charsets.UTF_8),
            1_000_000,
            0.01
        );
    }

    /**
     * 预加载所有有效 ID 到布隆过滤器
     */
    @PostConstruct
    public void init() {
        List<String> allIds = productMapper.selectAllIds();
        allIds.forEach(bloomFilter::put);
        log.info("布隆过滤器初始化完成，共加载 {} 个ID", allIds.size());
    }

    /**
     * 查询前先判断 ID 是否可能存在
     */
    public boolean mightExist(String id) {
        return bloomFilter.mightContain(id);
    }
}

/**
 * 方案二：空值缓存（防止重复穿透）
 */
public Product getProductWithNullCache(String productId) {
    String cacheKey = "product:" + productId;

    // 1. 布隆过滤器预判
    if (!bloomFilterCache.mightExist(productId)) {
        return null;  // 一定不存在，直接返回
    }

    // 2. 查缓存
    String cached = redisTemplate.opsForValue().get(cacheKey);

    // 3. 处理空值缓存标记
    if ("NULL".equals(cached)) {
        return null;  // 空值缓存命中，防止穿透
    }

    if (StringUtils.hasText(cached)) {
        return JSON.parseObject(cached, Product.class);
    }

    // 4. 查数据库
    Product product = productMapper.selectById(productId);

    // 5. 无论是否存在都写入缓存（空值设置较短TTL）
    if (product != null) {
        redisTemplate.opsForValue().set(
            cacheKey, JSON.toJSONString(product), Duration.ofHours(1));
    } else {
        // 空值缓存，短 TTL 防止穿透
        redisTemplate.opsForValue().set(
            cacheKey, "NULL", Duration.ofMinutes(5));
    }

    return product;
}

/**
 * 使用 Redisson 分布式锁保护热点 Key
 */
public Product getProductWithLock(String productId) {
    String cacheKey = "hot:product:" + productId;

    // 1. 查缓存
    String cached = redisTemplate.opsForValue().get(cacheKey);
    if (StringUtils.hasText(cached)) {
        return JSON.parseObject(cached, Product.class);
    }

    // 2. 缓存未命中，获取分布式锁（防止击穿）
    String lockKey = "lock:product:" + productId;
    RLock lock = redissonClient.getLock(lockKey);

    try {
        // 尝试获取锁，最多等待 500ms
        boolean locked = lock.tryLock(500, 3000, TimeUnit.MILLISECONDS);

        if (locked) {
            // Double Check：获取锁后再查一次缓存
            cached = redisTemplate.opsForValue().get(cacheKey);
            if (StringUtils.hasText(cached)) {
                return JSON.parseObject(cached, Product.class);
            }

            // 3. 查数据库并回填缓存
            Product product = productMapper.selectById(productId);
            if (product != null) {
                // 热点 Key 设置较短的 TTL 或永不过期
                redisTemplate.opsForValue().set(
                    cacheKey,
                    JSON.toJSONString(product),
                    Duration.ofMinutes(10)  // 较短 TTL
                );
            }
            return product;
        } else {
            // 获取锁失败，降级处理
            // 返回默认值或旧版本缓存
            return getDefaultProduct(productId);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return null;
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}